waitForPrepared := client.StackConfigurations.AwaitPrepared(ctx, stack.LatestStackConfiguration.ID)
for {
    result := <-waitForPrepared
    if result.Error != nil {
        return fmt.Errorf("error waiting for status: %w", result.Error)
    }
    if result.Quit {
        logf("%s reached quit status %s", result.ID, result.Status)
        return nil
    }
    logf("%s had status %s", result.ID, result.Status)
}

plans, err := client.StackPlans.ListByConfiguration(ctx, stack.LatestStackConfiguration.ID, nil)
if err != nil {
    return fmt.Errorf("error listing stack plans: %w", err)
}

c.logger.Debug().Msgf("Found %d plans for stack %s", len(plans.Items), stack.ID)

// Wait on all the plans to finish
planWaits := make([]<-chan tfe.WaitForStatusResult, len(plans.Items))
for idx, plan := range plans.Items {
    planWaits[idx] = client.StackPlans.AwaitTerminalState(ctx, plan.ID)
    logf("Waiting for plan %s to finish...", plan.ID)
}

// Fan-in all waitings
planFinished := make(chan tfe.WaitForStatusResult)
for _, ch := range planWaits {
go func() {
    for result := range ch {
        planFinished <- result
    }
}()
}

done := 0

loop:
for {
    select {
    case <-ctx.Done():
        return fmt.Errorf("context was canceled: %w", ctx.Err())
    case progress := <-planFinished:
        if progress.Error != nil {
            return fmt.Errorf("plan %q could not finish: %w", progress.ID, progress.Error)
        }
	logf("Plan %s has status %s", progress.ID, progress.Status)
	if progress.Quit {
            done += 1
            logf("Plan %s reached quit status %s", progress.ID, progress.Status)
            if done == len(plans.Items) {
                break loop
            }
        } else if progress.Status == "paused_planned" {
            err = client.StackPlans.Approve(ctx, progress.ID)
            if err != nil {
                return fmt.Errorf("error approving plan %q: %w", progress.ID, err)
            }
        }
    }
}